# ==================3.字符串==================
# @.字符串的定义
"""
1. Python 中字符串被定义为引号之间的字符集合。
2. Python 支持使用成对的 单引号 或 双引号。
1. 如果字符串中需要出现单引号或双引号，可以使用转义符号 \ 对字符串中的符号进行转义。
"""
str_1 = 'i love you zz'
print(str_1, type(str_1))

print(type(1 + 3))
print(type('5'))
print(type('5' + '3'))
# i love Python! <class 'str'>

print('let\'s go')

"""
Python的常用转义字符
\\      反斜杠符号
\'      单引号
\"      双引号
\n      换行
\t 横向制表符(TAB)
\r 回车
"""

print("C:\\Program Files\\Intel\\Wifi\\Help")

# 原始字符串只需要在字符串前边加一个英文字母 r 即可。
print(r'c:\asd\asd\asd')
print('c:\\asd\\asd\\asd')

# python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
str_multiple_line = """000
1
2
3
4
5   asd
asd ads ads
"""

print(str_multiple_line)

# @.字符串的切片 与拼接

"""
1. 类似于元组具有不可修改性
2. 从 0 开始 (和 C 一样)
3. 切片通常写成 start:end 这种形式，包括「 start 索引」对应的元素，不包括「 end 索引」对应的元素。
4. 索引值可正可负，正索引从 0 开始，从左往右；负索引从 -1 开始，从右往左。使用负数索引时，会从最后一个元素
开始计数。最后一个元素的位置编号是 -1。
"""
str1 = "i love you wifi"
print(str1[:6])  # i love
print(str1[3])  # o
print(str1[:6] + '插入' + str1[6:])

s = 'Python'

print(s[2:4])  # th
print(s[-5:-2])  # yth

# @.字符串的常用内置方法
"""
1. capitalize() 将字符串的第一个字符转换为大写。
2. upper() 转换字符串中的小写字母为大写。
3. swapcase 将字符串中大写转换为小写，小写转换为大写。
4. lower() 转换字符串中所有大写字符为小写。
"""
print(s, 'capitalize', s.capitalize())
print(s, 'upper', s.upper())
print(s, 'swapcase', s.swapcase())
print(s, 'lower', s.lower())

"""
count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定
范围内 str 出现的次数。
"""
repeat_str = 'xxxaaabbbcccxxxtvx'
print(len(repeat_str))
print(repeat_str.count('x'))  # 6
print(repeat_str.count('x', 0, 10))  # 3
print(repeat_str.count('x', 10, len(repeat_str)))  # 3

"""
1.endswith(suffix, beg=0, end=len(string)) 检查字符串是否以指定子字符串 suffix 结束，如果是，返回
True,否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
2. startswith(substr, beg=0,end=len(string)) 检查字符串是否以指定子字符串 substr 开头，如果是，返回
True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
"""
start_end = '0123456789'
print(start_end.endswith('5', 0, 5))  # False
print(start_end.endswith('5', 0, 6))  # True

print(start_end.startswith('5', 5, len(start_end)))  # True
print(start_end.startswith('5', 0, len(start_end)))  # False

"""
1.find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是
否包含在指定范围内，如果包含，返回开始的索引值，否则返回 -1。
2. rfind(str, beg=0,end=len(string)) 类似于 find() 函数，不过是从右边开始查找
"""

print(start_end.find('456') > -1)

# isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False。
print('isnumeric', start_end.isnumeric())

"""
1. ljust(width[, fillchar]) 返回一个原字符串左对齐，并使用 fillchar （默认空格）填充至长度 width 的新字
符串。
2. rjust(width[, fillchar]) 返回一个原字符串右对齐，并使用 fillchar （默认空格）填充至长度 width 的新字
符串。
"""
padStart = '123'
print('|' + padStart.ljust(10) + '|')
print('|' + padStart.rjust(10) + '|')
print('|' + padStart.ljust(10, '*') + '|')
print('|' + padStart.rjust(10, '*') + '|')

"""
1. lstrip([chars]) 截掉字符串左边的空格或指定字符。
2. rstrip([chars]) 删除字符串末尾的空格或指定字符。
3. strip([chars]) 在字符串上执行 lstrip() 和 rstrip() 。
"""
sep = '-'
trim = sep * 3 + 'aaaa' + sep * 3
print('|' + trim + '|')  # |---aaaa---|
print('|' + trim.lstrip(sep) + '|')  # |aaaa---|
print('|' + trim.rstrip(sep) + '|')  # |---aaaa|
print('|' + trim.strip(sep) + '|')  # |aaaa|

"""
1. partition(sub) 找到子字符串sub，把字符串分为一个三元组 (pre_sub,sub,fol_sub) ，如果字符串中不包含
sub则返回 ('原字符串','','') 。
2. rpartition(sub) 类似于 partition() 方法，不过是从右边开始查找。
"""
par = '123***456**789'
print(par.partition('**'), par.partition('**')[2])
print(par.rpartition('**'), par.partition('**')[2])
print(par.partition('--'), par.partition('--')[2])
print(par.rpartition('--'), par.rpartition('--')[2])

"""
1. replace(old, new [, max]) 把 将字符串中的 old 替换成 new ，如果 max 指定，则替换不超过 max 次。
2. split(str="", num) 不带参数默认是以空格为分隔符切片字符串，如果 num 参数有设置，则仅分隔 num 个子字符
串，返回切片后的子字符串拼接的列表。
"""
rep = '123***456**789'

print(rep, rep.replace('*', '_'))
print(rep, rep.replace('*', '_', 3))
str5 = ' I Love Wangyujin hubary'
str6 = str5.strip()  # 'I Love Wangyujin'

print(str6.split())  # ['I', 'Love', 'Wangyujin', 'hubary']
print(str6.split(' ', 2))  # ['I', 'Love', 'Wangyujin']

"""
1. splitlines([keepends]) 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为
False，不包含换行符，如果为 True，则保留换行符。
"""
print('123\r\n 456')
print('123\r456')
print('123\n456')

str6 = 'I \n Love \n LsgoGroup'
print(str6.splitlines())  # ['I ', ' Love ', ' LsgoGroup']
print(str6.splitlines(True))  # ['I \n', ' Love \n', ' LsgoGroup']

"""
maketrans(intab, outtab) 创建字符映射的转换表，第一个参数是字符串，表示需要转换的字符，第二个参数也
是字符串表示转换的目标。
2. translate(table, deletechars="") 根据参数 table 给出的表，转换字符串的字符，要过滤掉的字符放
到 deletechars 参数中。
"""

str_1 = 'this is string example....wow!!!'
make = str.maketrans('aeiou', '①②③④⑤')
print(make)  # {97: 9312, 101: 9313, 105: 9314, 111: 9315, 117: 9316}
print(str_1.translate(make))  # th3s 3s str3ng 2x1mpl2....w4w!!!

# @.字符串格式化
# Python format 格式化函数
str_23 = "{0} Love {1}".format('I', 'jjj')  # 位置参数
print(str_23)  # I Love jjj
"""
%c 格式化字符及其ASCII码
%s 格式化字符串，用str()方法处理对象
%r 格式化字符串，用rper()方法处理对象
%d 格式化整数
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数（大写）
%f 格式化浮点数字，可指定小数点后的精度
%c 格式化字符及其ASCII码
%s 格式化字符串，用str()方法处理对象
%r 格式化字符串，用rper()方法处理对象
%d 格式化整数
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数（大写）
%f 格式化浮点数字，可指定小数点后的精度
"""
print('%c' % 97)  # a
print('%c %c %c' % (97, 98, 99))  # a b c
print('%d + %d = %d' % (4, 5, 9))  # 4 + 5 = 9
print("我叫 %s 今年 %d 岁!" % ('小明', 10))  # 我叫 小明 今年 10 岁!
print('%o' % 10)  # 12
print('%x' % 10)  # a
print('%X' % 10)  # A
print('%f' % 27.658)  # 27.658000
print('%e' % 27.658)  # 2.765800e+01
print('%E' % 27.658)  # 2.765800E+01
print('%g' % 27.658)  # 27.658
text = "I am %d years old." % 22
print("I said: %s." % text)  # I said: I am 22 years old..
print("I said: %r." % text)  # I said: 'I am 22 years old.'

"""
1. 格式化操作符辅助指令
m.n m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)
- 用做左对齐
+ 在正数前面显示加号( + )
# 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
0 显示的数字前面填充'0'而不是默认的空格
"""

print('%5.1f' % 27.658)  # ' 27.7'
print('%.2e' % 27.658)  # 2.77e+01
print('%10d' % 10)  # ' 10'
print('%-10d' % 10)  # '10 '
print('%+d' % 10)  # +10
print('%#o' % 10)  # 0o12
print('%#x' % 108)  # 0x6c
print('%010d' % 5)  # 0000000005
